//! # API网关增强功能综合演示
//!
//! 本演示程序展示了RustCloud网关增强功能的主要特性：
//! - JWT认证和API Key认证
//! - 多维度限流控制
//! - 权限检查和资源授权
//! - 使用统计和监控

use std::sync::Arc;
use std::time::Duration;
use tokio;
use axum::http::HeaderMap;

// 导入网关增强模块
use rustcloud_gateway::auth::{
    AuthContext, AuthProvider, Principal, Resource, 
    JwtAuthProvider, JwtConfig, JwtClaims, JwtAlgorithm,
    ApiKeyAuthProvider, ApiKeyInfo,
    PrincipalType
};
use rustcloud_gateway::rate_limit::{
    RequestContext, RateLimiter, RateLimitConfig, RateLimitAlgorithmType,
    TokenBucketAlgorithm, IpBasedStrategy, UserBasedStrategy,
    MemoryStorage
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 简单的日志初始化
    println!("🚀 RustCloud API网关增强功能演示");
    println!("============================================");
    
    // 1. 演示JWT认证功能
    demo_jwt_authentication().await?;
    
    // 2. 演示API Key认证功能
    demo_api_key_authentication().await?;
    
    // 3. 演示限流控制功能
    demo_rate_limiting().await?;
    
    // 4. 演示权限检查功能
    demo_authorization().await?;
    
    // 5. 演示完整的网关请求处理流程
    demo_complete_request_flow().await?;
    
    println!("\n✅ 演示完成！API网关增强功能运行正常。");
    
    Ok(())
}

/// 演示JWT认证功能
async fn demo_jwt_authentication() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🔐 1. JWT认证功能演示");
    println!("------------------------");
    
    // 创建JWT认证提供者
    let jwt_config = JwtConfig {
        secret: "demo-secret-key-for-testing".to_string(),
        algorithm: JwtAlgorithm::HS256,
        issuer: Some("rustcloud-demo".to_string()),
        expiration: Duration::from_secs(3600), // 1小时
        ..Default::default()
    };
    
    let jwt_provider = JwtAuthProvider::new(jwt_config).await?;
    
    // 生成测试JWT令牌
    let claims = JwtClaims::new("user123".to_string(), Duration::from_secs(3600))
        .add_custom_claim("name".to_string(), serde_json::Value::String("张三".to_string()))
        .add_custom_claim("roles".to_string(), serde_json::Value::Array(vec![
            serde_json::Value::String("user".to_string()),
            serde_json::Value::String("read-only".to_string())
        ]));
    
    let token = jwt_provider.generate_token(&claims).await?;
    println!("✓ 生成JWT令牌: {}...", &token[..50]);
    
    // 创建认证上下文
    let mut headers = HeaderMap::new();
    headers.insert("authorization", format!("Bearer {}", token).parse()?);
    
    let auth_context = AuthContext::new(
        headers,
        "GET".to_string(),
        "/api/users".to_string(),
        Some("192.168.1.100".to_string()),
    );
    
    // 执行认证
    match jwt_provider.authenticate(&auth_context).await {
        Ok(principal) => {
            println!("✓ JWT认证成功!");
            println!("  用户ID: {}", principal.id);
            println!("  用户名: {}", principal.name);
            println!("  用户类型: {:?}", principal.principal_type);
            println!("  角色数量: {}", principal.roles.len());
            println!("  权限数量: {}", principal.permissions.len());
        }
        Err(e) => {
            println!("✗ JWT认证失败: {}", e);
        }
    }
    
    Ok(())
}

/// 演示API Key认证功能
async fn demo_api_key_authentication() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🔑 2. API Key认证功能演示");
    println!("------------------------");
    
    // 创建API Key认证提供者
    let api_key_provider = ApiKeyAuthProvider::new();
    
    // 生成并添加测试API Key
    let test_key = api_key_provider.generate_key();
    let key_info = ApiKeyInfo::new(
        "service:order-service".to_string(),
        vec![
            "order-service:read".to_string(),
            "order-service:write".to_string(),
        ],
    )
    .with_name("订单服务API密钥".to_string())
    .add_role("service".to_string())
    .with_daily_limit(10000);
    
    api_key_provider.add_key(test_key.clone(), key_info).await?;
    println!("✓ 生成API Key: {}", test_key);
    
    // 创建认证上下文（使用Header）
    let mut headers = HeaderMap::new();
    headers.insert("x-api-key", test_key.parse()?);
    
    let auth_context = AuthContext::new(
        headers,
        "POST".to_string(),
        "/api/orders".to_string(),
        Some("10.0.0.50".to_string()),
    );
    
    // 执行认证
    match api_key_provider.authenticate(&auth_context).await {
        Ok(principal) => {
            println!("✓ API Key认证成功!");
            println!("  服务ID: {}", principal.id);
            println!("  服务名: {}", principal.name);
            println!("  权限: {:?}", principal.permissions);
            
            // 显示使用统计
            let stats = api_key_provider.get_stats().await;
            println!("  统计信息:");
            println!("    总密钥数: {}", stats.total_keys);
            println!("    活跃密钥数: {}", stats.active_keys);
            println!("    总请求数: {}", stats.total_requests);
        }
        Err(e) => {
            println!("✗ API Key认证失败: {}", e);
        }
    }
    
    Ok(())
}

/// 演示限流控制功能
async fn demo_rate_limiting() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n⏱️  3. 限流控制功能演示");
    println!("------------------------");
    
    // 创建令牌桶算法和内存存储
    let storage = Arc::new(MemoryStorage::new());
    let algorithm = Box::new(TokenBucketAlgorithm::new(storage.clone()));
    
    // 创建限流配置
    let rate_config = RateLimitConfig {
        algorithm: RateLimitAlgorithmType::TokenBucket,
        max_requests: 10,
        window_duration: Duration::from_secs(60),
        burst_capacity: Some(5),
        refill_rate: Some(2),
        enabled: true,
        ..Default::default()
    };
    
    // 创建限流策略
    let ip_strategy = Box::new(IpBasedStrategy::new(rate_config.clone()));
    let user_strategy = Box::new(UserBasedStrategy::new(rate_config));
    
    // 创建限流器
    let rate_limiter = RateLimiter::new(algorithm, Box::new(MemoryStorage::new()))
        .add_strategy(ip_strategy)
        .add_strategy(user_strategy);
    
    // 模拟多个请求上下文
    let contexts = vec![
        RequestContext::new("/api/users".to_string(), "GET".to_string())
            .with_client_ip("192.168.1.100".parse()?)
            .with_user_id("user123".to_string()),
        RequestContext::new("/api/orders".to_string(), "POST".to_string())
            .with_client_ip("192.168.1.100".parse()?)
            .with_user_id("user123".to_string()),
        RequestContext::new("/api/products".to_string(), "GET".to_string())
            .with_client_ip("192.168.1.101".parse()?)
            .with_user_id("user456".to_string()),
    ];
    
    println!("✓ 限流器配置完成，开始测试请求...");
    
    // 测试限流决策
    for (i, context) in contexts.iter().enumerate() {
        match rate_limiter.is_allowed(context).await {
            Ok(decision) => {
                let status = if decision.allowed { "✓ 允许" } else { "✗ 拒绝" };
                println!("  请求 #{}: {} - IP: {:?}, 用户: {:?}, 剩余配额: {}", 
                         i + 1, 
                         status,
                         context.client_ip,
                         context.user_id,
                         decision.remaining);
            }
            Err(e) => {
                println!("  请求 #{}: 限流检查错误 - {}", i + 1, e);
            }
        }
    }
    
    // 显示限流统计信息
    let stats = rate_limiter.get_stats().await;
    println!("  限流统计:");
    println!("    总请求数: {}", stats.total_requests);
    println!("    拒绝请求数: {}", stats.rejected_requests);
    println!("    拒绝率: {:.2}%", stats.rejection_rate * 100.0);
    
    Ok(())
}

/// 演示权限检查功能
async fn demo_authorization() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🛡️  4. 权限检查功能演示");
    println!("------------------------");
    
    // 创建JWT认证提供者
    let jwt_config = JwtConfig::default();
    let jwt_provider = JwtAuthProvider::new(jwt_config).await?;
    
    // 创建不同权限级别的用户主体
    let admin_principal = Principal::new(
        "admin001".to_string(),
        "系统管理员".to_string(),
        PrincipalType::Admin,
    ).add_role("admin".to_string());
    
    let user_principal = Principal::new(
        "user123".to_string(),
        "普通用户".to_string(),
        PrincipalType::User,
    ).add_permission("user-service:get:/api/users".to_string())
     .add_permission("order-service:read".to_string());
    
    let service_principal = Principal::new(
        "order-service".to_string(),
        "订单服务".to_string(),
        PrincipalType::Service,
    ).add_permission("user-service:*".to_string())
     .add_permission("payment-service:write".to_string());
    
    // 定义测试资源
    let resources = vec![
        Resource::new("user-service".to_string(), "/api/users".to_string(), "GET".to_string()),
        Resource::new("user-service".to_string(), "/api/admin".to_string(), "DELETE".to_string()),
        Resource::new("order-service".to_string(), "/api/orders".to_string(), "POST".to_string()),
        Resource::new("payment-service".to_string(), "/api/payments".to_string(), "POST".to_string()),
    ];
    
    let principals = vec![
        ("管理员", &admin_principal),
        ("普通用户", &user_principal),
        ("订单服务", &service_principal),
    ];
    
    println!("✓ 开始权限检查测试...");
    
    for (principal_name, principal) in &principals {
        println!("\n  {} ({}):", principal_name, principal.id);
        
        for resource in &resources {
            match jwt_provider.authorize(principal, resource).await {
                Ok(allowed) => {
                    let status = if allowed { "✓ 允许" } else { "✗ 拒绝" };
                    println!("    {} {}:{} {} - {}", 
                             status,
                             resource.service,
                             resource.method,
                             resource.path,
                             resource.get_resource_id());
                }
                Err(e) => {
                    println!("    ✗ 权限检查错误: {}", e);
                }
            }
        }
    }
    
    Ok(())
}

/// 演示完整的网关请求处理流程
async fn demo_complete_request_flow() -> Result<(), Box<dyn std::error::Error>> {
    println!("\n🌐 5. 完整请求处理流程演示");
    println!("------------------------");
    
    // 1. 创建认证提供者
    let jwt_provider = JwtAuthProvider::new(JwtConfig::default()).await?;
    let api_key_provider = ApiKeyAuthProvider::new();
    
    // 添加测试API Key
    let test_key = "sk_demo_12345678";
    let key_info = ApiKeyInfo::new(
        "client-app".to_string(),
        vec!["user-service:read".to_string()],
    );
    api_key_provider.add_key(test_key.to_string(), key_info).await?;
    
    // 2. 创建限流器
    let storage = Arc::new(MemoryStorage::new());
    let algorithm = Box::new(TokenBucketAlgorithm::new(storage.clone()));
    let rate_config = RateLimitConfig::default();
    let rate_limiter = RateLimiter::new(algorithm, Box::new(MemoryStorage::new()))
        .add_strategy(Box::new(IpBasedStrategy::new(rate_config)));
    
    println!("✓ 网关组件初始化完成");
    
    // 3. 模拟完整的请求处理
    let test_requests = vec![
        ("API Key请求", create_api_key_request(test_key)),
        ("JWT令牌请求", create_jwt_request().await?),
        ("无认证请求", create_anonymous_request()),
    ];
    
    for (request_type, (auth_context, rate_context, resource)) in test_requests {
        println!("\n  处理 {}:", request_type);
        
        // 步骤1: 限流检查
        match rate_limiter.is_allowed(&rate_context).await {
            Ok(decision) if !decision.allowed => {
                println!("    ✗ 限流拒绝 - {}", decision.reason.unwrap_or_default());
                continue;
            }
            Ok(_) => println!("    ✓ 限流通过"),
            Err(e) => {
                println!("    ✗ 限流检查失败: {}", e);
                continue;
            }
        }
        
        // 步骤2: 认证检查
        let principal = if let Some(auth_context) = auth_context {
            // 尝试JWT认证
            if let Ok(principal) = jwt_provider.authenticate(&auth_context).await {
                println!("    ✓ JWT认证成功");
                Some(principal)
            }
            // 尝试API Key认证
            else if let Ok(principal) = api_key_provider.authenticate(&auth_context).await {
                println!("    ✓ API Key认证成功");
                Some(principal)
            } else {
                println!("    ✗ 认证失败");
                None
            }
        } else {
            println!("    - 无需认证");
            None
        };
        
        // 步骤3: 权限检查
        if let Some(principal) = principal {
            match jwt_provider.authorize(&principal, &resource).await {
                Ok(true) => println!("    ✓ 权限检查通过"),
                Ok(false) => {
                    println!("    ✗ 权限不足");
                    continue;
                }
                Err(e) => {
                    println!("    ✗ 权限检查失败: {}", e);
                    continue;
                }
            }
        }
        
        // 步骤4: 请求处理（模拟）
        println!("    ✓ 请求处理成功 - 200 OK");
    }
    
    Ok(())
}

/// 创建API Key请求的上下文
fn create_api_key_request(api_key: &str) -> (Option<AuthContext>, RequestContext, Resource) {
    let mut headers = HeaderMap::new();
    headers.insert("x-api-key", api_key.parse().unwrap());
    
    let auth_context = AuthContext::new(
        headers,
        "GET".to_string(),
        "/api/users".to_string(),
        Some("192.168.1.100".to_string()),
    );
    
    let rate_context = RequestContext::new("/api/users".to_string(), "GET".to_string())
        .with_client_ip("192.168.1.100".parse().unwrap());
    
    let resource = Resource::new(
        "user-service".to_string(),
        "/api/users".to_string(),
        "GET".to_string(),
    );
    
    (Some(auth_context), rate_context, resource)
}

/// 创建JWT请求的上下文
async fn create_jwt_request() -> Result<(Option<AuthContext>, RequestContext, Resource), Box<dyn std::error::Error>> {
    // 生成JWT令牌
    let jwt_provider = JwtAuthProvider::new(JwtConfig::default()).await?;
    let claims = JwtClaims::new("user123".to_string(), Duration::from_secs(3600));
    let token = jwt_provider.generate_token(&claims).await?;
    
    let mut headers = HeaderMap::new();
    headers.insert("authorization", format!("Bearer {}", token).parse()?);
    
    let auth_context = AuthContext::new(
        headers,
        "POST".to_string(),
        "/api/orders".to_string(),
        Some("10.0.0.20".to_string()),
    );
    
    let rate_context = RequestContext::new("/api/orders".to_string(), "POST".to_string())
        .with_client_ip("10.0.0.20".parse()?)
        .with_user_id("user123".to_string());
    
    let resource = Resource::new(
        "order-service".to_string(),
        "/api/orders".to_string(),
        "POST".to_string(),
    );
    
    Ok((Some(auth_context), rate_context, resource))
}

/// 创建匿名请求的上下文
fn create_anonymous_request() -> (Option<AuthContext>, RequestContext, Resource) {
    let rate_context = RequestContext::new("/api/health".to_string(), "GET".to_string())
        .with_client_ip("203.0.113.1".parse().unwrap());
    
    let resource = Resource::new(
        "health-service".to_string(),
        "/api/health".to_string(),
        "GET".to_string(),
    );
    
    (None, rate_context, resource)
}